Azure Maps Route Service (preview:2024-05-01)

2025/10/15 • 7 deleted methods

Route_PostRouteDirections (removed)
Description The `Route Directions` API is an HTTP `POST` request that returns the ideal route between an origin and destination for automobile (driving), commercial trucks and walking routes. The route passes through a series of waypoints if specified. A waypoint is a geographical location defined by longitude and latitude that is used for navigational purposes. The route considers factors such as current traffic and the typical road speeds on the requested day of the week and time of day. The API returns the distance, estimated travel time, and a representation of the route geometry. More routing information such as an optimized waypoint order or turn by turn instructions is also available, depending on the parameters used. The Route Directions considers local laws, vehicle dimensions, cargo type, max speed, bridge and tunnel heights to calculate the truck specific routes and avoid complex maneuvers and difficult roads. Not all trucks can travel the same routes as other vehicles due to certain restrictions based on the vehicle profile or cargo type. For example, highways often have separate speed limits for trucks, some roads don't allow trucks with flammable or hazardous materials, and there can be height and weight restriction on bridges. Up to 25 waypoints and 10 viaWaypoints between any two waypoints is supported for driving and walking routes. Each set of waypoints creates a separate route Leg. ViaWaypoints define the route path and can be used for route creation through specific locations, but they don't create route Legs. Truck routes support up to 150 waypoints but don't support viaWaypoints. For information about routing availability in countries/regions, see [Azure Maps routing coverage](https://learn.microsoft.com/azure/azure-maps/routing-coverage?pivots=route-v2). >[!Important] >By using this feature, you agree to the preview legal terms. For more information, see [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/).
Reference Link ¶

⚼ Request

POST:  /route/directions
{
api-version: string ,
x-ms-client-id: string ,
Accept-Language: string ,
routeDirectionsRequest:
{
type: enum ,
features:
[
{
type: enum ,
geometry: object ,
properties:
{
pointIndex: integer ,
pointType: enum ,
}
,
}
,
]
,
travelMode: enum ,
departAt: string ,
arriveAt: string ,
optimizeRoute: enum ,
optimizeWaypointOrder: boolean ,
avoid:
[
string ,
]
,
routeOutputOptions:
[
string ,
]
,
maxRouteCount: integer ,
heading: integer ,
vehicleSpec:
{
isVehicleCommercial: boolean ,
length: number ,
width: number ,
height: number ,
weight: integer ,
maxSpeed: integer ,
axleWeight: integer ,
axleCount: integer ,
loadType:
[
string ,
]
,
}
,
}
,
}

⚐ Response (200)

{
$schema: object ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_PostRouteDirectionsBatch (removed)
Description The `Route Directions Batch` API is an HTTP `POST` request that sends batches of up to **100** queries in a single call to the [Route Directions](/rest/api/maps/route/post-directions?view=rest-maps-2023-10-01-preview) API. >[!Important] >By using this feature, you agree to the preview legal terms. See the [Preview Supplemental Terms](https://azure.microsoft.com/support/legal/preview-supplemental-terms/) for additional details. ### Submit Synchronous Batch Request The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API. ``` POST https://atlas.microsoft.com/route/directions:batch?api-version=2023-10-01-preview ``` ### POST Body for Batch Request To send the _directions_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _directions_ queries: ``` { "batchItems": [ { "optionalId": "bbc9c0f6-ab52-49d8-a788-a658fa654c94", "type": "FeatureCollection", "features": [ { "type": "Feature", "geometry": { "coordinates": [ -122.3368, 47.614988 ], "type": "Point" }, "properties": { "pointIndex": 0, "pointType": "waypoint" } }, { "type": "Feature", "geometry": { "coordinates": [ -122.316067, 47.606356 ], "type": "Point" }, "properties": { "pointIndex": 1, "pointType": "waypoint" } } ], "optimizeRoute": "fastestWithoutTraffic", "routeOutputOptions": [ "routeSummary" ], "maxRouteCount": 3, "travelMode": "driving" }, { "optionalId": "a191de3c-1268-4986-98f0-03f0a5d9302a", "type": "FeatureCollection", "features": [ { "type": "Feature", "geometry": { "coordinates": [ -122.3368, 47.614988 ], "type": "Point" }, "properties": { "pointIndex": 0, "pointType": "waypoint" } }, { "type": "Feature", "geometry": { "coordinates": [ -122.316067, 47.606356 ], "type": "Point" }, "properties": { "pointIndex": 1, "pointType": "waypoint" } } ], "optimizeRoute": "shortest", "routeOutputOptions": [ "routeSummary" ], "maxRouteCount": 2, "travelMode": "driving" } ] } ``` A _directions_ batchItem object can accept any of the supported _directions_ [Request body](/rest/api/maps/route/post-directions?view=rest-maps-2023-10-01-preview#request-body) The batch should contain at least **1** query. ### Batch Response Model The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types: - [`DirectionsResponse`](/rest/api/maps/route/post-directions#response) - If the query completed successfully. - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
Reference Link ¶

⚼ Request

POST:  /route/directions:batch
{
x-ms-client-id: string ,
api-version: string ,
routeDirectionsBatchRequest:
{
batchItems:
[
object ,
]
,
}
,
}

⚐ Response (200)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (207)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_SubmitDirectionsAsynchronousBatch (removed)
Description The Directions Asynchronous Batch API is designed for processing large volumes of route direction queries asynchronously. This API is optimized for handling high-volume batch requests without the need for immediate response times, making it ideal for extensive geocoding operations. After submitting your batch request, the service processes the queries in the background. You can check the status of the request periodically and retrieve the results once they are available. This approach is beneficial for applications that can accommodate longer processing times and do not require instant responses. >[!Important] >By using this feature, you agree to the preview legal terms. For more information, see [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/). ### Submitting an Asynchronous Batch Request To submit a request, you must provide the following: - **`inputBlobUrl`**: A URL pointing to a blob storage that contains your batch of geocoding queries. The format of the data should be consistent with that used for the synchronous batch version. - **`outputStorageUrl`**: The destination URL where the batch results will be stored upon completion. - **`msiClientId`** (optional): The Client ID of a user-assigned managed identity. This is used for authentication and authorization of both `inputBlobUrl` and `outputStorageUrl`. If the managed identity is system-assigned, this field can be left null. The response header `Operation-Location` returns a URL with the Azure Maps geography endpoint `{geography}.atlas.microsoft.com`. To ensure that the endpoint returned in the `Operation-Location` header is the same as the submit job endpoint, using the geography endpoint is suggested.
Reference Link ¶

⚼ Request

POST:  /route/directions:asyncBatch
{
x-ms-client-id: string ,
api-version: string ,
Accept-Language: string ,
directionsAsyncBatchRequestBody:
{
inputBlobUrl: string ,
outputStorageUrl: string ,
msiClientId: string ,
}
,
}

⚐ Response (202)

{
operation-location: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_PostSnapToRoads (removed)
Description **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier). The Snap to Roads API accepts GPS point data, represented as latitude and longitude coordinates, and generates a route that aligns with existing roadways on a map. This process, known as "snapping to roads," produces a series of objects that trace a path closely following the road network. The resulting data includes road names and their respective speed limits, pertinent to the traversed segments. Moreover, the Snap to Roads API offers an interpolation feature, which refines the GPS points to create a smoother route that adheres to the road's geometry. This functionality is especially beneficial for asset tracking and enhancing data visualization in mapping applications. For information about routing availability in countries/regions, see [Azure Maps routing coverage](https://learn.microsoft.com/azure/azure-maps/routing-coverage?pivots=route-v2). >[!Important] >By using this feature, you agree to the preview legal terms. See the [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/) for additional details.
Reference Link ¶

⚼ Request

POST:  /route/snapToRoads
{
api-version: string ,
x-ms-client-id: string ,
Accept-Language: string ,
snapToRoadsRequest:
{
type: enum ,
features:
[
{
type: enum ,
geometry: object ,
properties: object ,
}
,
]
,
interpolate: boolean ,
includeSpeedLimit: boolean ,
travelMode: enum ,
}
,
}

⚐ Response (200)

{
type: enum ,
features:
[
object ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_PostSnapToRoadsBatch (removed)
Description **SnapToRoads Batch API** **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier). The Snap To Roads Batch API sends batches of up to **100** queries as a single call to the [Snap To Roads API](https://learn.microsoft.com/en-us/rest/api/maps/route/post-snap-to-roads?view=rest-maps-2024-05-01-preview). >[!Important] >By using this feature, you agree to the preview legal terms. See the [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/) for additional details. ### Submit Synchronous Batch Request The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API. ``` POST https://atlas.microsoft.com/route/snapToRoads:batch?api-version=2024-05-01-preview ``` ### POST Body for Batch Request To send the _snap to roads_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _snap to roads_ queries: ``` { "batchItems": [ { "type": "FeatureCollection", "features": [ { "type": "Feature", "geometry": { "coordinates": [ -122.122353, 47.672662 ], "type": "Point" }, "properties": { } }, { "type": "Feature", "geometry": { "coordinates": [ -122.132452, 47.644234 ], "type": "Point" }, "properties": { } } ], "interpolate": true, "includeSpeedLimit": true, "travelMode": "driving" }, { "type": "FeatureCollection", "features": [ { "type": "Feature", "geometry": { "coordinates": [ -122.33669, 47.590849 ], "type": "Point" }, "properties": { "pointIndex": 0 } }, { "type": "Feature", "geometry": { "coordinates": [ 122.34509, 47.610524 ], "type": "Point" }, "properties": { "pointIndex": 1 } } ], "interpolate": false, "includeSpeedLimit": false, "travelMode": "driving" } ] } ``` A _snap to roads_ batchItem object can accept any of the supported _snap to roads_ [Request body](/rest/api/maps/route/post-snap-to-roads?view=rest-maps-2024-05-01-preview#request-body) The batch should contain at least **1** query. ### Batch Response Model The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types: - [`SnapToRoadsResponse`](/rest/api/maps/route/post-snap-to-roads#response) - If the query completed successfully. - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
Reference Link ¶

⚼ Request

POST:  /route/snapToRoads:batch
{
x-ms-client-id: string ,
api-version: string ,
snapToRoadsBatchRequest:
{
batchItems:
[
object ,
]
,
}
,
}

⚐ Response (200)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (207)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_PostRouteRange (removed)
Description **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier). This service will calculate a set of locations that can be reached from the origin point based on fuel, energy, time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise orientation as well as the precise polygon center which was the result of the origin point. The returned polygon can be used for further processing such as [Search Inside Geometry](https://docs.microsoft.com/rest/api/maps/search/postsearchinsidegeometry) to search for POIs within the provided Isochrone. For information about routing availability in countries/regions, see [Azure Maps routing coverage](https://learn.microsoft.com/azure/azure-maps/routing-coverage?pivots=route-v2). >[!Important] >By using this feature, you agree to the preview legal terms. See the [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/) for additional details.
Reference Link ¶

⚼ Request

POST:  /route/range
{
api-version: string ,
x-ms-client-id: string ,
Accept-Language: string ,
routeRangeRequest:
{
type: enum ,
geometry: object ,
properties:
{
departAt: string ,
isSimplifiedPolygon: boolean ,
optimizeRoute: enum ,
avoid:
[
string ,
]
,
vehicleSpec:
{
isVehicleCommercial: boolean ,
length: number ,
width: number ,
height: number ,
weight: integer ,
maxSpeed: integer ,
axleWeight: integer ,
axleCount: integer ,
loadType:
[
string ,
]
,
}
,
distanceBudgetInMeters : number ,
timeBudgetInSec: number ,
thrilling:
{
windingness: enum ,
hilliness: enum ,
}
,
travelMode: enum ,
}
,
}
,
}

⚐ Response (200)

{
type: enum ,
features:
[
object ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}
Route_PostRouteRangeBatch (removed)
Description **Route Range Batch API** **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier). The Route Range Batch API sends batches of up to **100** queries as a single call to the [Route Range API](https://learn.microsoft.com/en-us/rest/api/maps/route/post-route-range?view=rest-maps-2024-05-01-preview). >[!Important] >By using this feature, you agree to the preview legal terms. See the [Preview Supplemental Terms](https://azure.microsoft.com/en-us/support/legal/preview-supplemental-terms/) for additional details. ### Submit Synchronous Batch Request The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API. ``` POST https://atlas.microsoft.com/route/range:batch?api-version=2024-05-01-preview ``` ### POST Body for Batch Request To send the _route range_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _route_range_ queries: ``` { "batchItems": [ { "type": "Feature", "geometry": { "type": "Point", "coordinates": [ 5.86605, 50.9745 ] }, "properties": { "timeBudgetInSec": 6000 } }, { "type": "Feature", "geometry": { "type": "Point", "coordinates": [ -122.201669, 47.615076 ] }, "properties": { "timeBudgetInSec": 2000 } } ] } ``` A _route range_ batchItem object can accept any of the supported _snap to roads_ [Request body](/rest/api/maps/route/post-snap-to-roads?view=rest-maps-2024-05-01-preview#request-body) The batch should contain at least **1** query. ### Batch Response Model The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types: - [`RouteRangeResponse`](/rest/api/maps/route/post-route-range#response) - If the query completed successfully. - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
Reference Link ¶

⚼ Request

POST:  /route/range:batch
{
x-ms-client-id: string ,
api-version: string ,
routeRangeBatchRequest:
{
batchItems:
[
object ,
]
,
}
,
}

⚐ Response (200)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (207)

{
summary:
{
successfulRequests: integer ,
totalRequests: integer ,
}
,
batchItems:
[
object ,
]
,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
innererror:
{
code: string ,
innererror: string ,
}
,
}
,
}
,
}